import { gql } from '@apollo/client';
import * as Apollo from '@apollo/client';
export type Maybe<T> = T | null;
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
const defaultOptions =  {}
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string;
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
  BigDecimal: any;
  Byte: any;
  Char: any;
  Long: any;
  Short: any;
  _ByteArray: any;
  _Date: any;
  _DateTime: any;
  _Float4: any;
  _OffsetDateTime: any;
  _Time: any;
};









export type Measure = {
  id: Scalars['ID'];
  description?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  type: Scalars['String'];
  aggregateRoot?: Maybe<RootDictionary>;
  _calc: _Calculation;
};


export type MeasureAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type RootDictionary = {
  id: Scalars['ID'];
  type: Scalars['String'];
  _calc: _Calculation;
};


export type Stakeholder = {
  id: Scalars['ID'];
  chgCnt?: Maybe<Scalars['Long']>;
  code?: Maybe<Scalars['String']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  name?: Maybe<Scalars['String']>;
  aggregateRoot?: Maybe<RootDictionary>;
  _calc: _Calculation;
};


export type StakeholderAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type Status = {
  id: Scalars['ID'];
  chgCnt?: Maybe<Scalars['Long']>;
  code?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  initial?: Maybe<Scalars['Boolean']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  name?: Maybe<Scalars['String']>;
  statusType?: Maybe<Scalars['String']>;
  stakeholder?: Maybe<Stakeholder>;
  aggregateRoot?: Maybe<RootDictionary>;
  _calc: _Calculation;
};


export type StatusStakeholderArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type StatusAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type StatusGraph = {
  id: Scalars['ID'];
  chgCnt?: Maybe<Scalars['Long']>;
  code?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  name?: Maybe<Scalars['String']>;
  statusFrom?: Maybe<Status>;
  statusTo?: Maybe<Status>;
  aggregateRoot?: Maybe<RootDictionary>;
  _calc: _Calculation;
};


export type StatusGraphStatusFromArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type StatusGraphStatusToArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type StatusGraphAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type SysAdminSettings = {
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  key?: Maybe<Scalars['String']>;
  value?: Maybe<Scalars['String']>;
  rootSecurity: SysRootSecurity;
  aggregateRoot?: Maybe<SysRootSecurity>;
  _calc: _Calculation;
};


export type SysAdminSettingsRootSecurityArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type SysAdminSettingsAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type SysCheckSelect = {
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  beforeCommitEnable?: Maybe<Scalars['Boolean']>;
  beforeOperationDisable?: Maybe<Scalars['Boolean']>;
  conditionValue?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  orderValue?: Maybe<Scalars['Int']>;
  typeName?: Maybe<Scalars['String']>;
  operation: SysOperation;
  aggregateRoot?: Maybe<SysRootSecurity>;
  _calc: _Calculation;
};


export type SysCheckSelectOperationArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type SysCheckSelectAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type SysOperation = {
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  allowEmptyChecks?: Maybe<Scalars['Boolean']>;
  body?: Maybe<Scalars['String']>;
  disableJwtVerification?: Maybe<Scalars['Boolean']>;
  hashValue?: Maybe<Scalars['String']>;
  rootSecurity: SysRootSecurity;
  aggregateRoot?: Maybe<SysRootSecurity>;
  checkSelects: _Ec_SysCheckSelect;
  paramAdditions: _Ec_SysParamAddition;
  _calc: _Calculation;
};


export type SysOperationRootSecurityArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type SysOperationAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type SysOperationCheckSelectsArgs = {
  elemAlias?: Maybe<Scalars['String']>;
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type SysOperationParamAdditionsArgs = {
  elemAlias?: Maybe<Scalars['String']>;
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};

export type SysParamAddition = {
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  paramAddition?: Maybe<Scalars['String']>;
  paramName?: Maybe<Scalars['String']>;
  operation: SysOperation;
  aggregateRoot?: Maybe<SysRootSecurity>;
  _calc: _Calculation;
};


export type SysParamAdditionOperationArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type SysParamAdditionAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type SysRootSecurity = {
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  type: Scalars['String'];
  adminSettings: _Ec_SysAdminSettings;
  operations: _Ec_SysOperation;
  _calc: _Calculation;
};


export type SysRootSecurityAdminSettingsArgs = {
  elemAlias?: Maybe<Scalars['String']>;
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type SysRootSecurityOperationsArgs = {
  elemAlias?: Maybe<Scalars['String']>;
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};

export type Tank = {
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  currentVal?: Maybe<Scalars['BigDecimal']>;
  tankOpenDate?: Maybe<Scalars['_Date']>;
  sysHistNumber?: Maybe<Scalars['Long']>;
  sysLastHistVersion?: Maybe<Scalars['Long']>;
  type: Scalars['String'];
  tankType: TankType;
  tankOperationList: _Ec_TankOperation;
  location: _G_Coordinates;
  owner: _G_CustomerReference;
  _calc: _Calculation;
};


export type TankTankTypeArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type TankTankOperationListArgs = {
  elemAlias?: Maybe<Scalars['String']>;
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};

export type TankHistory = {
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  currentVal?: Maybe<Scalars['BigDecimal']>;
  sysCurrentValUpdated?: Maybe<Scalars['Boolean']>;
  sysState?: Maybe<Scalars['Byte']>;
  sysHistNumber?: Maybe<Scalars['Long']>;
  sysLastHistVersion?: Maybe<Scalars['Long']>;
  sysChangeUser?: Maybe<Scalars['String']>;
  sysHistoryTime?: Maybe<Scalars['_OffsetDateTime']>;
  type: Scalars['String'];
  sysHistoryOwner: Tank;
  aggregateRoot?: Maybe<Tank>;
  _calc: _Calculation;
};


export type TankHistorySysHistoryOwnerArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type TankHistoryAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type TankOperation = {
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  kind?: Maybe<_En_TankOperKind>;
  operDateTimeUtc?: Maybe<Scalars['_OffsetDateTime']>;
  val?: Maybe<Scalars['BigDecimal']>;
  type: Scalars['String'];
  tank: Tank;
  aggregateRoot?: Maybe<Tank>;
  transfer: _G_TransferReference;
  customer: _G_CustomerReference;
  _calc: _Calculation;
};


export type TankOperationTankArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type TankOperationAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type TankType = {
  id: Scalars['ID'];
  description?: Maybe<Scalars['String']>;
  maxVal?: Maybe<Scalars['BigDecimal']>;
  minVal?: Maybe<Scalars['BigDecimal']>;
  name?: Maybe<Scalars['String']>;
  type: Scalars['String'];
  measure?: Maybe<Measure>;
  aggregateRoot?: Maybe<RootDictionary>;
  _calc: _Calculation;
};


export type TankTypeMeasureArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type TankTypeAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _Calculation = {
  __typename?: '_Calculation';
  char?: Maybe<Scalars['Char']>;
  string?: Maybe<Scalars['String']>;
  byte?: Maybe<Scalars['Byte']>;
  short?: Maybe<Scalars['Short']>;
  int?: Maybe<Scalars['Int']>;
  long?: Maybe<Scalars['Long']>;
  float?: Maybe<Scalars['_Float4']>;
  double?: Maybe<Scalars['Float']>;
  bigDecimal?: Maybe<Scalars['BigDecimal']>;
  date?: Maybe<Scalars['_Date']>;
  dateTime?: Maybe<Scalars['_DateTime']>;
  offsetDateTime?: Maybe<Scalars['_OffsetDateTime']>;
  time?: Maybe<Scalars['_Time']>;
  boolean?: Maybe<Scalars['Boolean']>;
  byteArray?: Maybe<Scalars['_ByteArray']>;
};


export type _CalculationCharArgs = {
  expr: Scalars['String'];
};


export type _CalculationStringArgs = {
  expr: Scalars['String'];
};


export type _CalculationByteArgs = {
  expr: Scalars['String'];
};


export type _CalculationShortArgs = {
  expr: Scalars['String'];
};


export type _CalculationIntArgs = {
  expr: Scalars['String'];
};


export type _CalculationLongArgs = {
  expr: Scalars['String'];
};


export type _CalculationFloatArgs = {
  expr: Scalars['String'];
};


export type _CalculationDoubleArgs = {
  expr: Scalars['String'];
};


export type _CalculationBigDecimalArgs = {
  expr: Scalars['String'];
};


export type _CalculationDateArgs = {
  expr: Scalars['String'];
};


export type _CalculationDateTimeArgs = {
  expr: Scalars['String'];
};


export type _CalculationOffsetDateTimeArgs = {
  expr: Scalars['String'];
};


export type _CalculationTimeArgs = {
  expr: Scalars['String'];
};


export type _CalculationBooleanArgs = {
  expr: Scalars['String'];
};


export type _CalculationByteArrayArgs = {
  expr: Scalars['String'];
};

export type _CompareMeasureInput = {
  name?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
};

export type _CompareTankInput = {
  tankOpenDate?: Maybe<Scalars['_Date']>;
};

export type _CompareTankOperationInput = {
  kind?: Maybe<_En_TankOperKind>;
  operDateTimeUtc?: Maybe<Scalars['_OffsetDateTime']>;
};

export type _CompareTankTypeInput = {
  name?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
};

export type _CoordinatesInput = {
  latitude?: Maybe<Scalars['String']>;
  longitude?: Maybe<Scalars['String']>;
};

export type _CreateMeasureInput = {
  name?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  id: Scalars['ID'];
};

export type _CreateTankInput = {
  owner?: Maybe<_SingleReferenceInput>;
  tankType: Scalars['ID'];
  location?: Maybe<_CoordinatesInput>;
  id: Scalars['ID'];
  tankOpenDate?: Maybe<Scalars['_Date']>;
  currentVal?: Maybe<Scalars['BigDecimal']>;
};

export type _CreateTankOperationInput = {
  val?: Maybe<Scalars['BigDecimal']>;
  transfer?: Maybe<_SingleReferenceInput>;
  kind?: Maybe<_En_TankOperKind>;
  operDateTimeUtc?: Maybe<Scalars['_OffsetDateTime']>;
  tank: Scalars['ID'];
  customer?: Maybe<_SingleReferenceInput>;
};

export type _CreateTankTypeInput = {
  maxVal?: Maybe<Scalars['BigDecimal']>;
  measure?: Maybe<Scalars['ID']>;
  minVal?: Maybe<Scalars['BigDecimal']>;
  name?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  id: Scalars['ID'];
};



export type _DeleteManyTankInput = {
  id: Scalars['ID'];
  compare?: Maybe<_CompareTankInput>;
};

export type _DeleteManyTankOperationInput = {
  id: Scalars['ID'];
  compare?: Maybe<_CompareTankOperationInput>;
};

export enum _DependsOnDependencyByGet {
  Exists = 'EXISTS',
  NotExists = 'NOT_EXISTS'
}

export enum _DependsOnDependencyByUpdateOrCreate {
  Created = 'CREATED',
  NotCreated = 'NOT_CREATED'
}

export type _DictionaryPacket = {
  __typename?: '_DictionaryPacket';
  getTankType?: Maybe<TankType>;
  updateOrCreateTankType?: Maybe<_UpdateOrCreateTankTypeResponse>;
  getMeasure?: Maybe<Measure>;
  updateOrCreateMeasure?: Maybe<_UpdateOrCreateMeasureResponse>;
  updateOrCreateManyTankType?: Maybe<Array<Maybe<_UpdateOrCreateManyResponse>>>;
  updateOrCreateManyMeasure?: Maybe<Array<Maybe<_UpdateOrCreateManyResponse>>>;
};


export type _DictionaryPacketGetTankTypeArgs = {
  id: Scalars['ID'];
  failOnEmpty?: Maybe<Scalars['Boolean']>;
  lock?: Maybe<_GetLockMode>;
};


export type _DictionaryPacketUpdateOrCreateTankTypeArgs = {
  input: _CreateTankTypeInput;
  exist?: Maybe<_ExistTankTypeInput>;
};


export type _DictionaryPacketGetMeasureArgs = {
  id: Scalars['ID'];
  failOnEmpty?: Maybe<Scalars['Boolean']>;
  lock?: Maybe<_GetLockMode>;
};


export type _DictionaryPacketUpdateOrCreateMeasureArgs = {
  input: _CreateMeasureInput;
  exist?: Maybe<_ExistMeasureInput>;
};


export type _DictionaryPacketUpdateOrCreateManyTankTypeArgs = {
  input: Array<Maybe<_UpdateOrCreateManyTankTypeInput>>;
};


export type _DictionaryPacketUpdateOrCreateManyMeasureArgs = {
  input: Array<Maybe<_UpdateOrCreateManyMeasureInput>>;
};

export type _Ec_Measure = {
  __typename?: '_EC_Measure';
  elems: Array<Measure>;
  count: Scalars['Int'];
};

export type _Ec_RootDictionary = {
  __typename?: '_EC_RootDictionary';
  elems: Array<RootDictionary>;
  count: Scalars['Int'];
};

export type _Ec_Stakeholder = {
  __typename?: '_EC_Stakeholder';
  elems: Array<Stakeholder>;
  count: Scalars['Int'];
};

export type _Ec_Status = {
  __typename?: '_EC_Status';
  elems: Array<Status>;
  count: Scalars['Int'];
};

export type _Ec_StatusGraph = {
  __typename?: '_EC_StatusGraph';
  elems: Array<StatusGraph>;
  count: Scalars['Int'];
};

export type _Ec_SysAdminSettings = {
  __typename?: '_EC_SysAdminSettings';
  elems: Array<SysAdminSettings>;
  count: Scalars['Int'];
};

export type _Ec_SysCheckSelect = {
  __typename?: '_EC_SysCheckSelect';
  elems: Array<SysCheckSelect>;
  count: Scalars['Int'];
};

export type _Ec_SysOperation = {
  __typename?: '_EC_SysOperation';
  elems: Array<SysOperation>;
  count: Scalars['Int'];
};

export type _Ec_SysParamAddition = {
  __typename?: '_EC_SysParamAddition';
  elems: Array<SysParamAddition>;
  count: Scalars['Int'];
};

export type _Ec_SysRootSecurity = {
  __typename?: '_EC_SysRootSecurity';
  elems: Array<SysRootSecurity>;
  count: Scalars['Int'];
};

export type _Ec_Tank = {
  __typename?: '_EC_Tank';
  elems: Array<Tank>;
  count: Scalars['Int'];
};

export type _Ec_TankHistory = {
  __typename?: '_EC_TankHistory';
  elems: Array<TankHistory>;
  count: Scalars['Int'];
};

export type _Ec_TankOperation = {
  __typename?: '_EC_TankOperation';
  elems: Array<TankOperation>;
  count: Scalars['Int'];
};

export type _Ec_TankType = {
  __typename?: '_EC_TankType';
  elems: Array<TankType>;
  count: Scalars['Int'];
};

export type _Enc_TankOperKind = {
  __typename?: '_ENC_TankOperKind';
  elems: Array<_En_TankOperKind>;
  count: Scalars['Int'];
};

export enum _En_TankOperKind {
  Cheking = 'CHEKING',
  Input = 'INPUT',
  Output = 'OUTPUT'
}

export type _E_Measure = _Entity & Measure & {
  __typename?: '_E_Measure';
  id: Scalars['ID'];
  description?: Maybe<Scalars['String']>;
  name?: Maybe<Scalars['String']>;
  type: Scalars['String'];
  aggregateRoot?: Maybe<RootDictionary>;
  _calc: _Calculation;
};


export type _E_MeasureAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type _E_RootDictionary = _Entity & RootDictionary & {
  __typename?: '_E_RootDictionary';
  id: Scalars['ID'];
  type: Scalars['String'];
  _calc: _Calculation;
};

export type _E_Stakeholder = _Entity & Stakeholder & {
  __typename?: '_E_Stakeholder';
  id: Scalars['ID'];
  chgCnt?: Maybe<Scalars['Long']>;
  code?: Maybe<Scalars['String']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  name?: Maybe<Scalars['String']>;
  aggregateRoot?: Maybe<RootDictionary>;
  _calc: _Calculation;
};


export type _E_StakeholderAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type _E_Status = _Entity & Status & {
  __typename?: '_E_Status';
  id: Scalars['ID'];
  chgCnt?: Maybe<Scalars['Long']>;
  code?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  initial?: Maybe<Scalars['Boolean']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  name?: Maybe<Scalars['String']>;
  statusType?: Maybe<Scalars['String']>;
  stakeholder?: Maybe<Stakeholder>;
  aggregateRoot?: Maybe<RootDictionary>;
  _calc: _Calculation;
};


export type _E_StatusStakeholderArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _E_StatusAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type _E_StatusGraph = _Entity & StatusGraph & {
  __typename?: '_E_StatusGraph';
  id: Scalars['ID'];
  chgCnt?: Maybe<Scalars['Long']>;
  code?: Maybe<Scalars['String']>;
  label?: Maybe<Scalars['String']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  name?: Maybe<Scalars['String']>;
  statusFrom?: Maybe<Status>;
  statusTo?: Maybe<Status>;
  aggregateRoot?: Maybe<RootDictionary>;
  _calc: _Calculation;
};


export type _E_StatusGraphStatusFromArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _E_StatusGraphStatusToArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _E_StatusGraphAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type _E_SysAdminSettings = _Entity & SysAdminSettings & {
  __typename?: '_E_SysAdminSettings';
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  key?: Maybe<Scalars['String']>;
  value?: Maybe<Scalars['String']>;
  rootSecurity: SysRootSecurity;
  aggregateRoot?: Maybe<SysRootSecurity>;
  _calc: _Calculation;
};


export type _E_SysAdminSettingsRootSecurityArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _E_SysAdminSettingsAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type _E_SysCheckSelect = _Entity & SysCheckSelect & {
  __typename?: '_E_SysCheckSelect';
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  beforeCommitEnable?: Maybe<Scalars['Boolean']>;
  beforeOperationDisable?: Maybe<Scalars['Boolean']>;
  conditionValue?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
  orderValue?: Maybe<Scalars['Int']>;
  typeName?: Maybe<Scalars['String']>;
  operation: SysOperation;
  aggregateRoot?: Maybe<SysRootSecurity>;
  _calc: _Calculation;
};


export type _E_SysCheckSelectOperationArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _E_SysCheckSelectAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type _E_SysOperation = _Entity & SysOperation & {
  __typename?: '_E_SysOperation';
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  allowEmptyChecks?: Maybe<Scalars['Boolean']>;
  body?: Maybe<Scalars['String']>;
  disableJwtVerification?: Maybe<Scalars['Boolean']>;
  hashValue?: Maybe<Scalars['String']>;
  rootSecurity: SysRootSecurity;
  aggregateRoot?: Maybe<SysRootSecurity>;
  checkSelects: _Ec_SysCheckSelect;
  paramAdditions: _Ec_SysParamAddition;
  _calc: _Calculation;
};


export type _E_SysOperationRootSecurityArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _E_SysOperationAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _E_SysOperationCheckSelectsArgs = {
  elemAlias?: Maybe<Scalars['String']>;
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _E_SysOperationParamAdditionsArgs = {
  elemAlias?: Maybe<Scalars['String']>;
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};

export type _E_SysParamAddition = _Entity & SysParamAddition & {
  __typename?: '_E_SysParamAddition';
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  paramAddition?: Maybe<Scalars['String']>;
  paramName?: Maybe<Scalars['String']>;
  operation: SysOperation;
  aggregateRoot?: Maybe<SysRootSecurity>;
  _calc: _Calculation;
};


export type _E_SysParamAdditionOperationArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _E_SysParamAdditionAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type _E_SysRootSecurity = _Entity & SysRootSecurity & {
  __typename?: '_E_SysRootSecurity';
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  type: Scalars['String'];
  adminSettings: _Ec_SysAdminSettings;
  operations: _Ec_SysOperation;
  _calc: _Calculation;
};


export type _E_SysRootSecurityAdminSettingsArgs = {
  elemAlias?: Maybe<Scalars['String']>;
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _E_SysRootSecurityOperationsArgs = {
  elemAlias?: Maybe<Scalars['String']>;
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};

export type _E_Tank = _Entity & Tank & {
  __typename?: '_E_Tank';
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  currentVal?: Maybe<Scalars['BigDecimal']>;
  tankOpenDate?: Maybe<Scalars['_Date']>;
  sysHistNumber?: Maybe<Scalars['Long']>;
  sysLastHistVersion?: Maybe<Scalars['Long']>;
  type: Scalars['String'];
  tankType: TankType;
  tankOperationList: _Ec_TankOperation;
  location: _G_Coordinates;
  owner: _G_CustomerReference;
  _calc: _Calculation;
};


export type _E_TankTankTypeArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _E_TankTankOperationListArgs = {
  elemAlias?: Maybe<Scalars['String']>;
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};

export type _E_TankHistory = _Entity & TankHistory & {
  __typename?: '_E_TankHistory';
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  currentVal?: Maybe<Scalars['BigDecimal']>;
  sysCurrentValUpdated?: Maybe<Scalars['Boolean']>;
  sysState?: Maybe<Scalars['Byte']>;
  sysHistNumber?: Maybe<Scalars['Long']>;
  sysLastHistVersion?: Maybe<Scalars['Long']>;
  sysChangeUser?: Maybe<Scalars['String']>;
  sysHistoryTime?: Maybe<Scalars['_OffsetDateTime']>;
  type: Scalars['String'];
  sysHistoryOwner: Tank;
  aggregateRoot?: Maybe<Tank>;
  _calc: _Calculation;
};


export type _E_TankHistorySysHistoryOwnerArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _E_TankHistoryAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type _E_TankOperation = _Entity & TankOperation & {
  __typename?: '_E_TankOperation';
  id: Scalars['ID'];
  aggVersion: Scalars['Long'];
  chgCnt?: Maybe<Scalars['Long']>;
  lastChangeDate?: Maybe<Scalars['_DateTime']>;
  ownerId?: Maybe<Scalars['String']>;
  kind?: Maybe<_En_TankOperKind>;
  operDateTimeUtc?: Maybe<Scalars['_OffsetDateTime']>;
  val?: Maybe<Scalars['BigDecimal']>;
  type: Scalars['String'];
  tank: Tank;
  aggregateRoot?: Maybe<Tank>;
  transfer: _G_TransferReference;
  customer: _G_CustomerReference;
  _calc: _Calculation;
};


export type _E_TankOperationTankArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _E_TankOperationAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type _E_TankType = _Entity & TankType & {
  __typename?: '_E_TankType';
  id: Scalars['ID'];
  description?: Maybe<Scalars['String']>;
  maxVal?: Maybe<Scalars['BigDecimal']>;
  minVal?: Maybe<Scalars['BigDecimal']>;
  name?: Maybe<Scalars['String']>;
  type: Scalars['String'];
  measure?: Maybe<Measure>;
  aggregateRoot?: Maybe<RootDictionary>;
  _calc: _Calculation;
};


export type _E_TankTypeMeasureArgs = {
  alias?: Maybe<Scalars['String']>;
};


export type _E_TankTypeAggregateRootArgs = {
  alias?: Maybe<Scalars['String']>;
};

export type _Entity = {
  id: Scalars['ID'];
};

export type _ExistMeasureInput = {
  update?: Maybe<_ExistUpdateMeasureInput>;
  compare?: Maybe<_CompareMeasureInput>;
};

export type _ExistTankInput = {
  update?: Maybe<_ExistUpdateTankInput>;
  inc?: Maybe<_IncTankInput>;
  compare?: Maybe<_CompareTankInput>;
};

export type _ExistTankTypeInput = {
  update?: Maybe<_ExistUpdateTankTypeInput>;
  inc?: Maybe<_IncTankTypeInput>;
  compare?: Maybe<_CompareTankTypeInput>;
};

export type _ExistUpdateMeasureInput = {
  name?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
};

export type _ExistUpdateTankInput = {
  owner?: Maybe<_SingleReferenceInput>;
  tankType?: Maybe<Scalars['ID']>;
  location?: Maybe<_CoordinatesInput>;
  tankOpenDate?: Maybe<Scalars['_Date']>;
  currentVal?: Maybe<Scalars['BigDecimal']>;
};

export type _ExistUpdateTankTypeInput = {
  maxVal?: Maybe<Scalars['BigDecimal']>;
  measure?: Maybe<Scalars['ID']>;
  minVal?: Maybe<Scalars['BigDecimal']>;
  name?: Maybe<Scalars['String']>;
  description?: Maybe<Scalars['String']>;
};


export type _G_Coordinates = {
  __typename?: '_G_Coordinates';
  latitude?: Maybe<Scalars['String']>;
  longitude?: Maybe<Scalars['String']>;
};

export type _G_CustomerReference = {
  __typename?: '_G_CustomerReference';
  entityId?: Maybe<Scalars['String']>;
};

export type _G_TransferReference = {
  __typename?: '_G_TransferReference';
  entityId?: Maybe<Scalars['String']>;
};

export enum _GetLockMode {
  NotUse = 'NOT_USE',
  Wait = 'WAIT',
  Nowait = 'NOWAIT'
}

export type _Hc_Tank = {
  __typename?: '_HC_Tank';
  elems: Array<_H_Tank>;
  count: Scalars['Int'];
};

export type _H_Tank = {
  __typename?: '_H_Tank';
  id: Scalars['ID'];
  ownerId?: Maybe<Scalars['String']>;
  currentVal?: Maybe<Scalars['BigDecimal']>;
  sysCurrentValUpdated?: Maybe<Scalars['Boolean']>;
  sysState?: Maybe<Scalars['Byte']>;
  sysHistNumber?: Maybe<Scalars['Long']>;
  sysLastHistVersion?: Maybe<Scalars['Long']>;
  sysChangeUser?: Maybe<Scalars['String']>;
  sysHistoryTime?: Maybe<Scalars['_OffsetDateTime']>;
  type: Scalars['String'];
  sysHistoryOwner?: Maybe<Scalars['String']>;
  aggregateRoot?: Maybe<Scalars['String']>;
};

export type _IncBigDecimalValueFailInput = {
  operator: _IncFailOperator;
  value: Scalars['BigDecimal'];
};

export type _IncBigDecimalValueInput = {
  value: Scalars['BigDecimal'];
  negative?: Maybe<Scalars['Boolean']>;
  fail?: Maybe<_IncBigDecimalValueFailInput>;
};

export enum _IncFailOperator {
  Lt = 'lt',
  Le = 'le',
  Gt = 'gt',
  Ge = 'ge'
}

export type _IncTankInput = {
  currentVal?: Maybe<_IncBigDecimalValueInput>;
};

export type _IncTankOperationInput = {
  val?: Maybe<_IncBigDecimalValueInput>;
};

export type _IncTankTypeInput = {
  maxVal?: Maybe<_IncBigDecimalValueInput>;
  minVal?: Maybe<_IncBigDecimalValueInput>;
};

export type _MergedEntitiesCollection = {
  __typename?: '_MergedEntitiesCollection';
  elems: Array<_Entity>;
  count: Scalars['Int'];
};

export type _Mutation = {
  __typename?: '_Mutation';
  packet?: Maybe<_Packet>;
  dictionaryPacket?: Maybe<_DictionaryPacket>;
};


export type _MutationPacketArgs = {
  aggregateVersion?: Maybe<Scalars['Long']>;
  idempotencePacketId?: Maybe<Scalars['String']>;
  enableBuffering?: Maybe<Scalars['Boolean']>;
};


export type _Packet = {
  __typename?: '_Packet';
  getStatus?: Maybe<Status>;
  getStakeholder?: Maybe<Stakeholder>;
  getTankType?: Maybe<TankType>;
  getMeasure?: Maybe<Measure>;
  getStatusGraph?: Maybe<StatusGraph>;
  createTankOperation?: Maybe<TankOperation>;
  updateTankOperation?: Maybe<TankOperation>;
  getTankOperation?: Maybe<TankOperation>;
  deleteTankOperation?: Maybe<Scalars['String']>;
  createTank?: Maybe<Tank>;
  updateOrCreateTank?: Maybe<_UpdateOrCreateTankResponse>;
  updateTank?: Maybe<Tank>;
  getTank?: Maybe<Tank>;
  deleteTank?: Maybe<Scalars['String']>;
  aggregateVersion?: Maybe<Scalars['Long']>;
  isIdempotenceResponse?: Maybe<Scalars['Boolean']>;
  createManyTankOperation?: Maybe<Array<Maybe<Scalars['String']>>>;
  updateManyTankOperation?: Maybe<Scalars['String']>;
  deleteManyTankOperation?: Maybe<Scalars['String']>;
  createManyTank?: Maybe<Array<Maybe<Scalars['String']>>>;
  updateOrCreateManyTank?: Maybe<Array<Maybe<_UpdateOrCreateManyResponse>>>;
  updateManyTank?: Maybe<Scalars['String']>;
  deleteManyTank?: Maybe<Scalars['String']>;
};


export type _PacketGetStatusArgs = {
  id: Scalars['ID'];
  failOnEmpty?: Maybe<Scalars['Boolean']>;
  lock?: Maybe<_GetLockMode>;
};


export type _PacketGetStakeholderArgs = {
  id: Scalars['ID'];
  failOnEmpty?: Maybe<Scalars['Boolean']>;
  lock?: Maybe<_GetLockMode>;
};


export type _PacketGetTankTypeArgs = {
  id: Scalars['ID'];
  failOnEmpty?: Maybe<Scalars['Boolean']>;
  lock?: Maybe<_GetLockMode>;
};


export type _PacketGetMeasureArgs = {
  id: Scalars['ID'];
  failOnEmpty?: Maybe<Scalars['Boolean']>;
  lock?: Maybe<_GetLockMode>;
};


export type _PacketGetStatusGraphArgs = {
  id: Scalars['ID'];
  failOnEmpty?: Maybe<Scalars['Boolean']>;
  lock?: Maybe<_GetLockMode>;
};


export type _PacketCreateTankOperationArgs = {
  input: _CreateTankOperationInput;
};


export type _PacketUpdateTankOperationArgs = {
  input: _UpdateTankOperationInput;
  compare?: Maybe<_CompareTankOperationInput>;
  inc?: Maybe<_IncTankOperationInput>;
};


export type _PacketGetTankOperationArgs = {
  id: Scalars['ID'];
  failOnEmpty?: Maybe<Scalars['Boolean']>;
  lock?: Maybe<_GetLockMode>;
};


export type _PacketDeleteTankOperationArgs = {
  id: Scalars['ID'];
  compare?: Maybe<_CompareTankOperationInput>;
};


export type _PacketCreateTankArgs = {
  input: _CreateTankInput;
};


export type _PacketUpdateOrCreateTankArgs = {
  input: _CreateTankInput;
  exist?: Maybe<_ExistTankInput>;
};


export type _PacketUpdateTankArgs = {
  input: _UpdateTankInput;
  compare?: Maybe<_CompareTankInput>;
  inc?: Maybe<_IncTankInput>;
};


export type _PacketGetTankArgs = {
  id: Scalars['ID'];
  failOnEmpty?: Maybe<Scalars['Boolean']>;
  lock?: Maybe<_GetLockMode>;
};


export type _PacketDeleteTankArgs = {
  id: Scalars['ID'];
  compare?: Maybe<_CompareTankInput>;
};


export type _PacketCreateManyTankOperationArgs = {
  input: Array<_CreateTankOperationInput>;
};


export type _PacketUpdateManyTankOperationArgs = {
  input: Array<Maybe<_UpdateManyTankOperationInput>>;
};


export type _PacketDeleteManyTankOperationArgs = {
  input: Array<Maybe<_DeleteManyTankOperationInput>>;
};


export type _PacketCreateManyTankArgs = {
  input: Array<_CreateTankInput>;
};


export type _PacketUpdateOrCreateManyTankArgs = {
  input: Array<Maybe<_UpdateOrCreateManyTankInput>>;
};


export type _PacketUpdateManyTankArgs = {
  input: Array<Maybe<_UpdateManyTankInput>>;
};


export type _PacketDeleteManyTankArgs = {
  input: Array<Maybe<_DeleteManyTankInput>>;
};

export type _Query = {
  __typename?: '_Query';
  merge: _MergedEntitiesCollection;
  resolveReferences: Array<_Reference>;
  searchMeasure: _Ec_Measure;
  searchTank: _Ec_Tank;
  searchTankOperation: _Ec_TankOperation;
  searchTankType: _Ec_TankType;
  searchStakeholder: _Ec_Stakeholder;
  searchStatus: _Ec_Status;
  searchStatusGraph: _Ec_StatusGraph;
  searchRootDictionary: _Ec_RootDictionary;
  searchSysRootSecurity: _Ec_SysRootSecurity;
  searchSysAdminSettings: _Ec_SysAdminSettings;
  searchSysOperation: _Ec_SysOperation;
  searchSysCheckSelect: _Ec_SysCheckSelect;
  searchSysParamAddition: _Ec_SysParamAddition;
  searchTankHistory: _Ec_TankHistory;
  getStateTank?: Maybe<_S_Tank>;
  getStatesTank: _Sc_Tank;
  getTankHistory: _Hc_Tank;
};


export type _QueryMergeArgs = {
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QueryResolveReferencesArgs = {
  referenceType: Scalars['String'];
  ids: Array<Scalars['ID']>;
};


export type _QuerySearchMeasureArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchTankArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchTankOperationArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchTankTypeArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchStakeholderArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchStatusArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchStatusGraphArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchRootDictionaryArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchSysRootSecurityArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchSysAdminSettingsArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchSysOperationArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchSysCheckSelectArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchSysParamAdditionArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QuerySearchTankHistoryArgs = {
  cond?: Maybe<Scalars['String']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<Array<_SortCriterionSpecification>>;
};


export type _QueryGetStateTankArgs = {
  id: Scalars['ID'];
  date: Scalars['_OffsetDateTime'];
};


export type _QueryGetStatesTankArgs = {
  id: Scalars['ID'];
  timeFrom?: Maybe<Scalars['_OffsetDateTime']>;
  timeTo?: Maybe<Scalars['_OffsetDateTime']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<_SortOrder>;
};


export type _QueryGetTankHistoryArgs = {
  id: Scalars['ID'];
  timeFrom?: Maybe<Scalars['_OffsetDateTime']>;
  timeTo?: Maybe<Scalars['_OffsetDateTime']>;
  limit?: Maybe<Scalars['Int']>;
  offset?: Maybe<Scalars['Int']>;
  sort?: Maybe<_SortOrder>;
};

export type _R_Measure = _Reference & {
  __typename?: '_R_Measure';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<Measure>;
};

export type _R_RootDictionary = _Reference & {
  __typename?: '_R_RootDictionary';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<RootDictionary>;
};

export type _R_Stakeholder = _Reference & {
  __typename?: '_R_Stakeholder';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<Stakeholder>;
};

export type _R_Status = _Reference & {
  __typename?: '_R_Status';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<Status>;
};

export type _R_StatusGraph = _Reference & {
  __typename?: '_R_StatusGraph';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<StatusGraph>;
};

export type _R_SysAdminSettings = _Reference & {
  __typename?: '_R_SysAdminSettings';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<SysAdminSettings>;
};

export type _R_SysCheckSelect = _Reference & {
  __typename?: '_R_SysCheckSelect';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<SysCheckSelect>;
};

export type _R_SysOperation = _Reference & {
  __typename?: '_R_SysOperation';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<SysOperation>;
};

export type _R_SysParamAddition = _Reference & {
  __typename?: '_R_SysParamAddition';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<SysParamAddition>;
};

export type _R_SysRootSecurity = _Reference & {
  __typename?: '_R_SysRootSecurity';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<SysRootSecurity>;
};

export type _R_Tank = _Reference & {
  __typename?: '_R_Tank';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<Tank>;
};

export type _R_TankHistory = _Reference & {
  __typename?: '_R_TankHistory';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<TankHistory>;
};

export type _R_TankOperation = _Reference & {
  __typename?: '_R_TankOperation';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<TankOperation>;
};

export type _R_TankType = _Reference & {
  __typename?: '_R_TankType';
  entityId?: Maybe<Scalars['String']>;
  entity?: Maybe<TankType>;
};

export type _Reference = {
  entityId?: Maybe<Scalars['String']>;
};

export type _Sc_Tank = {
  __typename?: '_SC_Tank';
  elems: Array<_Ss_Tank>;
  count: Scalars['Int'];
};

export type _Ss_Tank = {
  __typename?: '_SS_Tank';
  id: Scalars['ID'];
  ownerId?: Maybe<Scalars['String']>;
  currentVal?: Maybe<Scalars['BigDecimal']>;
  sysCurrentValUpdated?: Maybe<Scalars['Boolean']>;
  sysState?: Maybe<Scalars['Byte']>;
  sysHistNumber?: Maybe<Scalars['Long']>;
  sysLastHistVersion?: Maybe<Scalars['Long']>;
  sysChangeUser?: Maybe<Scalars['String']>;
  sysHistoryTime?: Maybe<Scalars['_OffsetDateTime']>;
  type: Scalars['String'];
  sysHistoryOwner?: Maybe<Scalars['String']>;
  aggregateRoot?: Maybe<Scalars['String']>;
};

export type _S_Tank = {
  __typename?: '_S_Tank';
  ownerId?: Maybe<Scalars['String']>;
  currentVal?: Maybe<Scalars['BigDecimal']>;
  sysCurrentValUpdated?: Maybe<Scalars['Boolean']>;
  sysHistNumber?: Maybe<Scalars['Long']>;
  sysChangeUser?: Maybe<Scalars['String']>;
  type: Scalars['String'];
  sysHistoryOwner?: Maybe<Scalars['String']>;
  aggregateRoot?: Maybe<Scalars['String']>;
};

export type _SingleReferenceInput = {
  entityId: Scalars['String'];
};

export type _SortCriterionSpecification = {
  crit: Scalars['String'];
  order?: _SortOrder;
  nullsLast?: Maybe<Scalars['Boolean']>;
};

export enum _SortOrder {
  Asc = 'ASC',
  Desc = 'DESC'
}


export type _UpdateManyTankInput = {
  param: _UpdateTankInput;
  compare?: Maybe<_CompareTankInput>;
  inc?: Maybe<_IncTankInput>;
};

export type _UpdateManyTankOperationInput = {
  param: _UpdateTankOperationInput;
  compare?: Maybe<_CompareTankOperationInput>;
  inc?: Maybe<_IncTankOperationInput>;
};

export type _UpdateOrCreateManyMeasureInput = {
  param: _CreateMeasureInput;
  exist?: Maybe<_ExistMeasureInput>;
};

export type _UpdateOrCreateManyResponse = {
  __typename?: '_UpdateOrCreateManyResponse';
  id?: Maybe<Scalars['ID']>;
  created?: Maybe<Scalars['Boolean']>;
};

export type _UpdateOrCreateManyTankInput = {
  param: _CreateTankInput;
  exist?: Maybe<_ExistTankInput>;
};

export type _UpdateOrCreateManyTankTypeInput = {
  param: _CreateTankTypeInput;
  exist?: Maybe<_ExistTankTypeInput>;
};

export type _UpdateOrCreateMeasureResponse = {
  __typename?: '_UpdateOrCreateMeasureResponse';
  created?: Maybe<Scalars['Boolean']>;
  returning?: Maybe<Measure>;
};

export type _UpdateOrCreateTankResponse = {
  __typename?: '_UpdateOrCreateTankResponse';
  created?: Maybe<Scalars['Boolean']>;
  returning?: Maybe<Tank>;
};

export type _UpdateOrCreateTankTypeResponse = {
  __typename?: '_UpdateOrCreateTankTypeResponse';
  created?: Maybe<Scalars['Boolean']>;
  returning?: Maybe<TankType>;
};

export type _UpdateTankInput = {
  owner?: Maybe<_SingleReferenceInput>;
  tankType?: Maybe<Scalars['ID']>;
  location?: Maybe<_CoordinatesInput>;
  tankOpenDate?: Maybe<Scalars['_Date']>;
  currentVal?: Maybe<Scalars['BigDecimal']>;
  id: Scalars['ID'];
};

export type _UpdateTankOperationInput = {
  val?: Maybe<Scalars['BigDecimal']>;
  transfer?: Maybe<_SingleReferenceInput>;
  kind?: Maybe<_En_TankOperKind>;
  operDateTimeUtc?: Maybe<Scalars['_OffsetDateTime']>;
  tank?: Maybe<Scalars['ID']>;
  customer?: Maybe<_SingleReferenceInput>;
  id: Scalars['ID'];
};

export type TankTypeAttributesFragment = (
  { __typename: '_E_TankType' }
  & Pick<_E_TankType, 'id' | 'name' | 'minVal' | 'maxVal'>
  & { measure?: Maybe<(
    { __typename: '_E_Measure' }
    & Pick<_E_Measure, 'id' | 'name'>
  )> }
);

export type SearchTankTypeQueryVariables = Exact<{ [key: string]: never; }>;


export type SearchTankTypeQuery = (
  { __typename?: '_Query' }
  & { searchTankType: (
    { __typename?: '_EC_TankType' }
    & { elems: Array<(
      { __typename?: '_E_TankType' }
      & TankTypeAttributesFragment
    )> }
  ) }
);

export type TankAttributesFragment = (
  { __typename: '_E_Tank' }
  & Pick<_E_Tank, 'id' | 'tankOpenDate' | 'currentVal'>
  & { location: (
    { __typename?: '_G_Coordinates' }
    & Pick<_G_Coordinates, 'latitude' | 'longitude'>
  ), tankType: (
    { __typename?: '_E_TankType' }
    & Pick<_E_TankType, 'id' | 'name'>
  ), owner: (
    { __typename?: '_G_CustomerReference' }
    & Pick<_G_CustomerReference, 'entityId'>
  ) }
);

export type SearchTankQueryVariables = Exact<{
  cond?: Maybe<Scalars['String']>;
}>;


export type SearchTankQuery = (
  { __typename?: '_Query' }
  & { searchTank: (
    { __typename?: '_EC_Tank' }
    & { elems: Array<(
      { __typename?: '_E_Tank' }
      & TankAttributesFragment
    )> }
  ) }
);

export type CreateTankMutationVariables = Exact<{
  input: _CreateTankInput;
}>;


export type CreateTankMutation = (
  { __typename?: '_Mutation' }
  & { packet?: Maybe<(
    { __typename?: '_Packet' }
    & { createTank?: Maybe<(
      { __typename?: '_E_Tank' }
      & TankAttributesFragment
    )> }
  )> }
);

export type UpdateTankMutationVariables = Exact<{
  input: _UpdateTankInput;
}>;


export type UpdateTankMutation = (
  { __typename?: '_Mutation' }
  & { packet?: Maybe<(
    { __typename?: '_Packet' }
    & { updateTank?: Maybe<(
      { __typename?: '_E_Tank' }
      & TankAttributesFragment
    )> }
  )> }
);

export type DeleteTankMutationVariables = Exact<{
  id: Scalars['ID'];
}>;


export type DeleteTankMutation = (
  { __typename?: '_Mutation' }
  & { packet?: Maybe<(
    { __typename?: '_Packet' }
    & Pick<_Packet, 'deleteTank'>
  )> }
);

export type TankOperationAttributesFragment = (
  { __typename: '_E_TankOperation' }
  & Pick<_E_TankOperation, 'id' | 'kind' | 'val'>
  & { transfer: (
    { __typename?: '_G_TransferReference' }
    & Pick<_G_TransferReference, 'entityId'>
  ), aggregateRoot?: Maybe<(
    { __typename?: '_E_Tank' }
    & Pick<_E_Tank, 'id'>
  )> }
);

export type SearchTankOperationQueryVariables = Exact<{
  cond?: Maybe<Scalars['String']>;
}>;


export type SearchTankOperationQuery = (
  { __typename?: '_Query' }
  & { searchTankOperation: (
    { __typename?: '_EC_TankOperation' }
    & { elems: Array<(
      { __typename?: '_E_TankOperation' }
      & TankOperationAttributesFragment
    )> }
  ) }
);

export type IncreaseTankValMutationVariables = Exact<{
  tankId: Scalars['ID'];
  val: Scalars['BigDecimal'];
  transferRef?: Maybe<_SingleReferenceInput>;
}>;


export type IncreaseTankValMutation = (
  { __typename?: '_Mutation' }
  & { packet?: Maybe<(
    { __typename?: '_Packet' }
    & { updateTank?: Maybe<(
      { __typename: '_E_Tank' }
      & Pick<_E_Tank, 'id' | 'currentVal'>
    )>, createTankOperation?: Maybe<(
      { __typename?: '_E_TankOperation' }
      & TankOperationAttributesFragment
    )> }
  )> }
);

export type DecreaseTankValMutationVariables = Exact<{
  tankId: Scalars['ID'];
  val: Scalars['BigDecimal'];
  transferRef?: Maybe<_SingleReferenceInput>;
}>;


export type DecreaseTankValMutation = (
  { __typename?: '_Mutation' }
  & { packet?: Maybe<(
    { __typename?: '_Packet' }
    & { updateTank?: Maybe<(
      { __typename: '_E_Tank' }
      & Pick<_E_Tank, 'id' | 'currentVal'>
    )>, createTankOperation?: Maybe<(
      { __typename?: '_E_TankOperation' }
      & TankOperationAttributesFragment
    )> }
  )> }
);

export const TankTypeAttributesFragmentDoc = gql`
    fragment TankTypeAttributes on _E_TankType {
  id
  __typename
  name
  minVal
  maxVal
  measure {
    id
    __typename
    name
  }
}
    `;
export const TankAttributesFragmentDoc = gql`
    fragment TankAttributes on _E_Tank {
  id
  __typename
  tankOpenDate
  currentVal
  location {
    latitude
    longitude
  }
  tankType {
    id
    name
  }
  owner {
    entityId
  }
}
    `;
export const TankOperationAttributesFragmentDoc = gql`
    fragment TankOperationAttributes on _E_TankOperation {
  id
  __typename
  kind
  val
  transfer {
    entityId
  }
  aggregateRoot {
    id
  }
}
    `;
export const SearchTankTypeDocument = gql`
    query searchTankType {
  searchTankType {
    elems {
      ...TankTypeAttributes
    }
  }
}
    ${TankTypeAttributesFragmentDoc}`;

/**
 * __useSearchTankTypeQuery__
 *
 * To run a query within a React component, call `useSearchTankTypeQuery` and pass it any options that fit your needs.
 * When your component renders, `useSearchTankTypeQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useSearchTankTypeQuery({
 *   variables: {
 *   },
 * });
 */
export function useSearchTankTypeQuery(baseOptions?: Apollo.QueryHookOptions<SearchTankTypeQuery, SearchTankTypeQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<SearchTankTypeQuery, SearchTankTypeQueryVariables>(SearchTankTypeDocument, options);
      }
export function useSearchTankTypeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchTankTypeQuery, SearchTankTypeQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<SearchTankTypeQuery, SearchTankTypeQueryVariables>(SearchTankTypeDocument, options);
        }
export type SearchTankTypeQueryHookResult = ReturnType<typeof useSearchTankTypeQuery>;
export type SearchTankTypeLazyQueryHookResult = ReturnType<typeof useSearchTankTypeLazyQuery>;
export type SearchTankTypeQueryResult = Apollo.QueryResult<SearchTankTypeQuery, SearchTankTypeQueryVariables>;
export const SearchTankDocument = gql`
    query searchTank($cond: String) {
  searchTank(cond: $cond) {
    elems {
      ...TankAttributes
    }
  }
}
    ${TankAttributesFragmentDoc}`;

/**
 * __useSearchTankQuery__
 *
 * To run a query within a React component, call `useSearchTankQuery` and pass it any options that fit your needs.
 * When your component renders, `useSearchTankQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useSearchTankQuery({
 *   variables: {
 *      cond: // value for 'cond'
 *   },
 * });
 */
export function useSearchTankQuery(baseOptions?: Apollo.QueryHookOptions<SearchTankQuery, SearchTankQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<SearchTankQuery, SearchTankQueryVariables>(SearchTankDocument, options);
      }
export function useSearchTankLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchTankQuery, SearchTankQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<SearchTankQuery, SearchTankQueryVariables>(SearchTankDocument, options);
        }
export type SearchTankQueryHookResult = ReturnType<typeof useSearchTankQuery>;
export type SearchTankLazyQueryHookResult = ReturnType<typeof useSearchTankLazyQuery>;
export type SearchTankQueryResult = Apollo.QueryResult<SearchTankQuery, SearchTankQueryVariables>;
export const CreateTankDocument = gql`
    mutation createTank($input: _CreateTankInput!) {
  packet {
    createTank(input: $input) {
      ...TankAttributes
    }
  }
}
    ${TankAttributesFragmentDoc}`;
export type CreateTankMutationFn = Apollo.MutationFunction<CreateTankMutation, CreateTankMutationVariables>;

/**
 * __useCreateTankMutation__
 *
 * To run a mutation, you first call `useCreateTankMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateTankMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [createTankMutation, { data, loading, error }] = useCreateTankMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useCreateTankMutation(baseOptions?: Apollo.MutationHookOptions<CreateTankMutation, CreateTankMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<CreateTankMutation, CreateTankMutationVariables>(CreateTankDocument, options);
      }
export type CreateTankMutationHookResult = ReturnType<typeof useCreateTankMutation>;
export type CreateTankMutationResult = Apollo.MutationResult<CreateTankMutation>;
export type CreateTankMutationOptions = Apollo.BaseMutationOptions<CreateTankMutation, CreateTankMutationVariables>;
export const UpdateTankDocument = gql`
    mutation updateTank($input: _UpdateTankInput!) {
  packet {
    updateTank(input: $input) {
      ...TankAttributes
    }
  }
}
    ${TankAttributesFragmentDoc}`;
export type UpdateTankMutationFn = Apollo.MutationFunction<UpdateTankMutation, UpdateTankMutationVariables>;

/**
 * __useUpdateTankMutation__
 *
 * To run a mutation, you first call `useUpdateTankMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateTankMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateTankMutation, { data, loading, error }] = useUpdateTankMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdateTankMutation(baseOptions?: Apollo.MutationHookOptions<UpdateTankMutation, UpdateTankMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<UpdateTankMutation, UpdateTankMutationVariables>(UpdateTankDocument, options);
      }
export type UpdateTankMutationHookResult = ReturnType<typeof useUpdateTankMutation>;
export type UpdateTankMutationResult = Apollo.MutationResult<UpdateTankMutation>;
export type UpdateTankMutationOptions = Apollo.BaseMutationOptions<UpdateTankMutation, UpdateTankMutationVariables>;
export const DeleteTankDocument = gql`
    mutation deleteTank($id: ID!) {
  packet {
    deleteTank(id: $id)
  }
}
    `;
export type DeleteTankMutationFn = Apollo.MutationFunction<DeleteTankMutation, DeleteTankMutationVariables>;

/**
 * __useDeleteTankMutation__
 *
 * To run a mutation, you first call `useDeleteTankMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteTankMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [deleteTankMutation, { data, loading, error }] = useDeleteTankMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export function useDeleteTankMutation(baseOptions?: Apollo.MutationHookOptions<DeleteTankMutation, DeleteTankMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<DeleteTankMutation, DeleteTankMutationVariables>(DeleteTankDocument, options);
      }
export type DeleteTankMutationHookResult = ReturnType<typeof useDeleteTankMutation>;
export type DeleteTankMutationResult = Apollo.MutationResult<DeleteTankMutation>;
export type DeleteTankMutationOptions = Apollo.BaseMutationOptions<DeleteTankMutation, DeleteTankMutationVariables>;
export const SearchTankOperationDocument = gql`
    query searchTankOperation($cond: String) {
  searchTankOperation(cond: $cond) {
    elems {
      ...TankOperationAttributes
    }
  }
}
    ${TankOperationAttributesFragmentDoc}`;

/**
 * __useSearchTankOperationQuery__
 *
 * To run a query within a React component, call `useSearchTankOperationQuery` and pass it any options that fit your needs.
 * When your component renders, `useSearchTankOperationQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useSearchTankOperationQuery({
 *   variables: {
 *      cond: // value for 'cond'
 *   },
 * });
 */
export function useSearchTankOperationQuery(baseOptions?: Apollo.QueryHookOptions<SearchTankOperationQuery, SearchTankOperationQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<SearchTankOperationQuery, SearchTankOperationQueryVariables>(SearchTankOperationDocument, options);
      }
export function useSearchTankOperationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchTankOperationQuery, SearchTankOperationQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<SearchTankOperationQuery, SearchTankOperationQueryVariables>(SearchTankOperationDocument, options);
        }
export type SearchTankOperationQueryHookResult = ReturnType<typeof useSearchTankOperationQuery>;
export type SearchTankOperationLazyQueryHookResult = ReturnType<typeof useSearchTankOperationLazyQuery>;
export type SearchTankOperationQueryResult = Apollo.QueryResult<SearchTankOperationQuery, SearchTankOperationQueryVariables>;
export const IncreaseTankValDocument = gql`
    mutation increaseTankVal($tankId: ID!, $val: BigDecimal!, $transferRef: _SingleReferenceInput) {
  packet {
    updateTank(input: {id: $tankId}, inc: {currentVal: {value: $val}}) {
      id
      __typename
      currentVal
    }
    createTankOperation(
      input: {tank: $tankId, val: $val, kind: INPUT, transfer: $transferRef}
    ) {
      ...TankOperationAttributes
    }
  }
}
    ${TankOperationAttributesFragmentDoc}`;
export type IncreaseTankValMutationFn = Apollo.MutationFunction<IncreaseTankValMutation, IncreaseTankValMutationVariables>;

/**
 * __useIncreaseTankValMutation__
 *
 * To run a mutation, you first call `useIncreaseTankValMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useIncreaseTankValMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [increaseTankValMutation, { data, loading, error }] = useIncreaseTankValMutation({
 *   variables: {
 *      tankId: // value for 'tankId'
 *      val: // value for 'val'
 *      transferRef: // value for 'transferRef'
 *   },
 * });
 */
export function useIncreaseTankValMutation(baseOptions?: Apollo.MutationHookOptions<IncreaseTankValMutation, IncreaseTankValMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<IncreaseTankValMutation, IncreaseTankValMutationVariables>(IncreaseTankValDocument, options);
      }
export type IncreaseTankValMutationHookResult = ReturnType<typeof useIncreaseTankValMutation>;
export type IncreaseTankValMutationResult = Apollo.MutationResult<IncreaseTankValMutation>;
export type IncreaseTankValMutationOptions = Apollo.BaseMutationOptions<IncreaseTankValMutation, IncreaseTankValMutationVariables>;
export const DecreaseTankValDocument = gql`
    mutation decreaseTankVal($tankId: ID!, $val: BigDecimal!, $transferRef: _SingleReferenceInput) {
  packet {
    updateTank(
      input: {id: $tankId}
      inc: {currentVal: {value: $val, negative: true}}
    ) {
      id
      __typename
      currentVal
    }
    createTankOperation(
      input: {tank: $tankId, val: $val, kind: OUTPUT, transfer: $transferRef}
    ) {
      ...TankOperationAttributes
    }
  }
}
    ${TankOperationAttributesFragmentDoc}`;
export type DecreaseTankValMutationFn = Apollo.MutationFunction<DecreaseTankValMutation, DecreaseTankValMutationVariables>;

/**
 * __useDecreaseTankValMutation__
 *
 * To run a mutation, you first call `useDecreaseTankValMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDecreaseTankValMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [decreaseTankValMutation, { data, loading, error }] = useDecreaseTankValMutation({
 *   variables: {
 *      tankId: // value for 'tankId'
 *      val: // value for 'val'
 *      transferRef: // value for 'transferRef'
 *   },
 * });
 */
export function useDecreaseTankValMutation(baseOptions?: Apollo.MutationHookOptions<DecreaseTankValMutation, DecreaseTankValMutationVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useMutation<DecreaseTankValMutation, DecreaseTankValMutationVariables>(DecreaseTankValDocument, options);
      }
export type DecreaseTankValMutationHookResult = ReturnType<typeof useDecreaseTankValMutation>;
export type DecreaseTankValMutationResult = Apollo.MutationResult<DecreaseTankValMutation>;
export type DecreaseTankValMutationOptions = Apollo.BaseMutationOptions<DecreaseTankValMutation, DecreaseTankValMutationVariables>;